package com.wicket.okrapp.web.contorller;

import com.github.pagehelper.Page;
import com.wicket.okrapp.biz.service.CycleTypeService;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.ro.OkrResult;
import com.wicket.okrcomponent.common.util.CommonFunctionHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@RestController
@RequestMapping("/app/cycleType/")
public class CycleTypeController {

    @Autowired
    CycleTypeService cycleTypeService;

    /**
   * D3-4查询周期详情
   */
    @PostMapping("queryCycleDetail")
    public OkrResult<QueryCycleDetailRespDto> queryCycleDetail(@RequestBody @Validated QueryCycleDetailReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryCycleDetail(reqDTO));
    }

    /**
   * D3-4查询工作周期类型关系列表
   */
    @PostMapping("queryCycleTypeInstanceRelationshipList")
    public OkrResult<QueryCycleTypeInstanceRelationshipListRespDto> queryCycleTypeInstanceRelationshipList(@RequestBody @Validated QueryCycleTypeInstanceRelationshipListReqDto reqDTO){
    Page<?> page = CommonFunctionHelper.startPage(reqDTO.getPageNum(),reqDTO.getPageSize());

        QueryCycleTypeInstanceRelationshipListRespDto retData = cycleTypeService.queryCycleTypeInstanceRelationshipList(reqDTO);

        retData.setPageNum(page.getPageNum());
        retData.setPageSize(page.getPageSize());
        retData.setTotalNum(page.getTotal());
        return OkrResult.success(retData);
    
    }

    /**
   * D3-4新增工作周期类型关系
   */
    @PostMapping("addCycleTypeInstanceRelationship")
    public OkrResult<AddCycleTypeInstanceRelationshipRespDto> addCycleTypeInstanceRelationship(@RequestBody @Validated AddCycleTypeInstanceRelationshipReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addCycleTypeInstanceRelationship(reqDTO));
    }

    /**
   * D3-4批量修改周期类型排序
   */
    @PostMapping("batchUpdateCycleTypeSort")
    public OkrResult<BatchUpdateCycleTypeSortRespDto> batchUpdateCycleTypeSort(@RequestBody @Validated BatchUpdateCycleTypeSortReqDto reqDTO){
    return OkrResult.success(cycleTypeService.batchUpdateCycleTypeSort(reqDTO));
    }

    /**
   * D3-4查询周期列表
   */
    @PostMapping("queryCycleList")
    public OkrResult<QueryCycleListRespDto> queryCycleList(@RequestBody @Validated QueryCycleListReqDto reqDTO){
    Page<?> page = CommonFunctionHelper.startPage(reqDTO.getPageNum(),reqDTO.getPageSize());

        QueryCycleListRespDto retData = cycleTypeService.queryCycleList(reqDTO);

        retData.setPageNum(page.getPageNum());
        retData.setPageSize(page.getPageSize());
        retData.setTotalNum(page.getTotal());
        return OkrResult.success(retData);
    
    }

    /**
   * D3-4修改周期
   */
    @PostMapping("updateCycle")
    public OkrResult<UpdateCycleRespDto> updateCycle(@RequestBody @Validated UpdateCycleReqDto reqDTO){
    return OkrResult.success(cycleTypeService.updateCycle(reqDTO));
    }

    /**
   * D3-4新增周期
   */
    @PostMapping("addCycle")
    public OkrResult<AddCycleRespDto> addCycle(@RequestBody @Validated AddCycleReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addCycle(reqDTO));
    }

    /**
     * D3-4查询周期类型实例详情
     */
    @PostMapping("queryCycleTypeInstanceDetail")
    public OkrResult<QueryCycleTypeInstanceDetailRespDto> queryCycleTypeInstanceDetail(@RequestBody @Validated QueryCycleTypeInstanceDetailReqDto reqDTO) {
        return OkrResult.success(cycleTypeService.queryCycleTypeInstanceDetail(reqDTO));
    }

    /**
   * D3-4查询周期类型详情
   */
    @PostMapping("queryCycleTypeDetail")
    public OkrResult<QueryCycleTypeDetailRespDto> queryCycleTypeDetail(@RequestBody @Validated QueryCycleTypeDetailReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryCycleTypeDetail(reqDTO));
    }

    /**
     * D3-4修改工作周期类型关系
     */
    @PostMapping("updateCycleTypeInstanceRelationship")
    public OkrResult<UpdateCycleTypeInstanceRelationshipRespDto> updateCycleTypeInstanceRelationship(@RequestBody @Validated UpdateCycleTypeInstanceRelationshipReqDto reqDTO) {
        return OkrResult.success(cycleTypeService.updateCycleTypeInstanceRelationship(reqDTO));
    }

    /**
   * D3-4查询周期类型实例列表
   */
    @PostMapping("queryCycleTypeInstanceList")
    public OkrResult<QueryCycleTypeInstanceListRespDto> queryCycleTypeInstanceList(@RequestBody @Validated QueryCycleTypeInstanceListReqDto reqDTO){
    Page<?> page = CommonFunctionHelper.startPage(reqDTO.getPageNum(),reqDTO.getPageSize());

        QueryCycleTypeInstanceListRespDto retData = cycleTypeService.queryCycleTypeInstanceList(reqDTO);

        retData.setPageNum(page.getPageNum());
        retData.setPageSize(page.getPageSize());
        retData.setTotalNum(page.getTotal());
        return OkrResult.success(retData);
    
    }

    /**
   * D3-4修改周期类型实例
   */
    @PostMapping("updateCycleTypeInstance")
    public OkrResult<UpdateCycleTypeInstanceRespDto> updateCycleTypeInstance(@RequestBody @Validated UpdateCycleTypeInstanceReqDto reqDTO){
    return OkrResult.success(cycleTypeService.updateCycleTypeInstance(reqDTO));
    }

    /**
   * D3-4新增周期类型实例
   */
    @PostMapping("addCycleTypeInstance")
    public OkrResult<AddCycleTypeInstanceRespDto> addCycleTypeInstance(@RequestBody @Validated AddCycleTypeInstanceReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addCycleTypeInstance(reqDTO));
    }

    /**
   * D3-4查询周期类型列表
   */
    @PostMapping("queryCycleTypeList")
    public OkrResult<QueryCycleTypeListRespDto> queryCycleTypeList(@RequestBody @Validated QueryCycleTypeListReqDto reqDTO){
    Page<?> page = CommonFunctionHelper.startPage(reqDTO.getPageNum(),reqDTO.getPageSize());

        QueryCycleTypeListRespDto retData = cycleTypeService.queryCycleTypeList(reqDTO);

        retData.setPageNum(page.getPageNum());
        retData.setPageSize(page.getPageSize());
        retData.setTotalNum(page.getTotal());
        return OkrResult.success(retData);
    
    }

    /**
   * D3-4修改周期类型
   */
    @PostMapping("updateCycleType")
    public OkrResult<UpdateCycleTypeRespDto> updateCycleType(@RequestBody @Validated UpdateCycleTypeReqDto reqDTO){
    return OkrResult.success(cycleTypeService.updateCycleType(reqDTO));
    }

    /**
   * D3-4新增周期类型
   */
    @PostMapping("addCycleType")
    public OkrResult<AddCycleTypeRespDto> addCycleType(@RequestBody @Validated AddCycleTypeReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addCycleType(reqDTO));
    }
/**
   * D3-4查询周期详情(公共)
   */
    @PostMapping("queryCycleDetailCom")
    public OkrResult<QueryCycleDetailComRespDto> queryCycleDetailCom(@RequestBody @Validated QueryCycleDetailComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryCycleDetailCom(reqDTO));
    }
/**
   * D3-查询子周期列表(公共)
   */
    @PostMapping("querySubcycleListCom")
    public OkrResult<QuerySubcycleListComRespDto> querySubcycleListCom(@RequestBody @Validated QuerySubcycleListComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.querySubcycleListCom(reqDTO));
    }
/**
   * D3-查询上一周期详情(公共)
   */
    @PostMapping("queryLastCycleDetailCom")
    public OkrResult<QueryLastCycleDetailComRespDto> queryLastCycleDetailCom(@RequestBody @Validated QueryLastCycleDetailComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryLastCycleDetailCom(reqDTO));
    }
/**
   * D3-4新增周期类型(公共)
   */
    @PostMapping("addCycleTypeCom")
    public OkrResult<AddCycleTypeComRespDto> addCycleTypeCom(@RequestBody @Validated AddCycleTypeComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addCycleTypeCom(reqDTO));
    }
/**
   * D3生成周期排序服务(公共)
   */
    @PostMapping("generateOrderNumberCom")
    public OkrResult<GenerateOrderNumberComRespDto> generateOrderNumberCom(@RequestBody @Validated GenerateOrderNumberComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.generateOrderNumberCom(reqDTO));
    }
/**
   * D3-4新增内容周期(公共)
   */
    @PostMapping("addContentCycleCom")
    public OkrResult<AddContentCycleComRespDto> addContentCycleCom(@RequestBody @Validated AddContentCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addContentCycleCom(reqDTO));
    }
/**
   * D3-4检查生成不存在的周期(公共)
   */
    @PostMapping("checkCycleCom")
    public OkrResult<CheckCycleComRespDto> checkCycleCom(@RequestBody @Validated CheckCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.checkCycleCom(reqDTO));
    }
/**
   * D3-4查周期列表(边界)
   */
    @PostMapping("queryCycleListBorder")
    public OkrResult<QueryCycleListBorderRespDto> queryCycleListBorder(@RequestBody @Validated QueryCycleListBorderReqDto reqDTO){
    Page<?> page = CommonFunctionHelper.startPage(reqDTO.getPageNum(),reqDTO.getPageSize());

        QueryCycleListBorderRespDto retData = cycleTypeService.queryCycleListBorder(reqDTO);

        retData.setPageNum(page.getPageNum());
        retData.setPageSize(page.getPageSize());
        retData.setTotalNum(page.getTotal());
        return OkrResult.success(retData);
    
    }
/**
   * D3-4查询周期倒序列表
   */
    @PostMapping("queryCycleSortList")
    public OkrResult<QueryCycleSortListRespDto> queryCycleSortList(@RequestBody @Validated QueryCycleSortListReqDto reqDTO){
    Page<?> page = CommonFunctionHelper.startPage(reqDTO.getPageNum(),reqDTO.getPageSize());

        QueryCycleSortListRespDto retData = cycleTypeService.queryCycleSortList(reqDTO);

        retData.setPageNum(page.getPageNum());
        retData.setPageSize(page.getPageSize());
        retData.setTotalNum(page.getTotal());
        return OkrResult.success(retData);
    
    }
/**
   * D3-4查询父子中周期列表
   */
    @PostMapping("queryParentSonMidCycleList")
    public OkrResult<QueryParentSonMidCycleListRespDto> queryParentSonMidCycleList(@RequestBody @Validated QueryParentSonMidCycleListReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryParentSonMidCycleList(reqDTO));
    }
/**
   * D3-4查询中期周期详情
   */
    @PostMapping("queryMidCycleDetail")
    public OkrResult<QueryMidCycleDetailRespDto> queryMidCycleDetail(@RequestBody @Validated QueryMidCycleDetailReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryMidCycleDetail(reqDTO));
    }
/**
   * D3-查询综合周期列表(公共)
   */
    @PostMapping("querySyntheticalCycleListCom")
    public OkrResult<QuerySyntheticalCycleListComRespDto> querySyntheticalCycleListCom(@RequestBody @Validated QuerySyntheticalCycleListComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.querySyntheticalCycleListCom(reqDTO));
    }
/**
   * D3-查询周期列表(公共)
   */
    @PostMapping("queryCycleListCom")
    public OkrResult<QueryCycleListComRespDto> queryCycleListCom(@RequestBody @Validated QueryCycleListComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryCycleListCom(reqDTO));
    }
/**
   * D3-4执行检查周期类型(公共)
   */
    @PostMapping("implementCheckCycleTypeCom")
    public OkrResult<ImplementCheckCycleTypeComRespDto> implementCheckCycleTypeCom(@RequestBody @Validated ImplementCheckCycleTypeComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.implementCheckCycleTypeCom(reqDTO));
    }
/**
   * D3-查询租户周期列表
   */
    @PostMapping("queryTenantCycleList")
    public OkrResult<QueryTenantCycleListRespDto> queryTenantCycleList(@RequestBody @Validated QueryTenantCycleListReqDto reqDTO){
    Page<?> page = CommonFunctionHelper.startPage(reqDTO.getPageNum(),reqDTO.getPageSize());

        QueryTenantCycleListRespDto retData = cycleTypeService.queryTenantCycleList(reqDTO);

        retData.setPageNum(page.getPageNum());
        retData.setPageSize(page.getPageSize());
        retData.setTotalNum(page.getTotal());
        return OkrResult.success(retData);

    }
/**
   * D3查询租户周期类型列表
   */
    @PostMapping("queryTenantCycleTypeList")
    public OkrResult<QueryTenantCycleTypeListRespDto> queryTenantCycleTypeList(@RequestBody @Validated QueryTenantCycleTypeListReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryTenantCycleTypeList(reqDTO));
    }
/**
   * D3删除租户周期
   */
    @PostMapping("deleteTenantCycle")
    public OkrResult<DeleteTenantCycleRespDto> deleteTenantCycle(@RequestBody @Validated DeleteTenantCycleReqDto reqDTO){
    return OkrResult.success(cycleTypeService.deleteTenantCycle(reqDTO));
    }
/**
   * D3查询租户周期导航列表
   */
    @PostMapping("queryTenantCycleNavigationList")
    public OkrResult<QueryTenantCycleNavigationListRespDto> queryTenantCycleNavigationList(@RequestBody @Validated QueryTenantCycleNavigationListReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryTenantCycleNavigationList(reqDTO));
    }
/**
   * D3查询租户节假日设置列表
   */
    @PostMapping("queryTenantHolidaySetList")
    public OkrResult<QueryTenantHolidaySetListRespDto> queryTenantHolidaySetList(@RequestBody @Validated QueryTenantHolidaySetListReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryTenantHolidaySetList(reqDTO));
    }
/**
   * D3查询租户节假日设置详情
   */
    @PostMapping("queryTenantHolidaySetDetail")
    public OkrResult<QueryTenantHolidaySetDetailRespDto> queryTenantHolidaySetDetail(@RequestBody @Validated QueryTenantHolidaySetDetailReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryTenantHolidaySetDetail(reqDTO));
    }
/**
   * D3查询租户节假日菜单列表
   */
    @PostMapping("queryTenantHolidayMenuList")
    public OkrResult<QueryTenantHolidayMenuListRespDto> queryTenantHolidayMenuList(@RequestBody @Validated QueryTenantHolidayMenuListReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryTenantHolidayMenuList(reqDTO));
    }
/**
   * D2新增租户节假日设置
   */
    @PostMapping("addTenantHolidaySet")
    public OkrResult<AddTenantHolidaySetRespDto> addTenantHolidaySet(@RequestBody @Validated AddTenantHolidaySetReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addTenantHolidaySet(reqDTO));
    }
/**
   * D3修改租户节假日设置
   */
    @PostMapping("updateTenantHolidaySet")
    public OkrResult<UpdateTenantHolidaySetRespDto> updateTenantHolidaySet(@RequestBody @Validated UpdateTenantHolidaySetReqDto reqDTO){
    return OkrResult.success(cycleTypeService.updateTenantHolidaySet(reqDTO));
    }
/**
   * D3删除租户节假日设置
   */
    @PostMapping("deleteTenantHolidaySet")
    public OkrResult<DeleteTenantHolidaySetRespDto> deleteTenantHolidaySet(@RequestBody @Validated DeleteTenantHolidaySetReqDto reqDTO){
    return OkrResult.success(cycleTypeService.deleteTenantHolidaySet(reqDTO));
    }
/**
   * D3存档租户节假日设置
   */
    @PostMapping("archiveTenantHolidaySet")
    public OkrResult<ArchiveTenantHolidaySetRespDto> archiveTenantHolidaySet(@RequestBody @Validated ArchiveTenantHolidaySetReqDto reqDTO){
    return OkrResult.success(cycleTypeService.archiveTenantHolidaySet(reqDTO));
    }
/**
   * D3查询租户周期类型实例列表
   */
    @PostMapping("queryTenantCycleTypeInstanceList")
    public OkrResult<QueryTenantCycleTypeInstanceListRespDto> queryTenantCycleTypeInstanceList(@RequestBody @Validated QueryTenantCycleTypeInstanceListReqDto reqDTO){
    return OkrResult.success(cycleTypeService.queryTenantCycleTypeInstanceList(reqDTO));
    }
/**
   * D3执行判断节假日处理策略(公共)
   */
    @PostMapping("implementStageHolidayStrategyCom")
    public OkrResult<ImplementStageHolidayStrategyComRespDto> implementStageHolidayStrategyCom(@RequestBody @Validated ImplementStageHolidayStrategyComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.implementStageHolidayStrategyCom(reqDTO));
    }
/**
   * D3执行判断时间点前后偏移N天(公共)
   */
    @PostMapping("implementJudgeOffsetNdaysInTimePointIntervalCom")
    public OkrResult<ImplementJudgeOffsetNdaysInTimePointIntervalComRespDto> implementJudgeOffsetNdaysInTimePointIntervalCom(@RequestBody @Validated ImplementJudgeOffsetNdaysInTimePointIntervalComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.implementJudgeOffsetNdaysInTimePointIntervalCom(reqDTO));
    }
/**
   * D3执行动态判断接收起始点(公共)
   */
    @PostMapping("implementJudgmentStartingPointCom")
    public OkrResult<ImplementJudgmentStartingPointComRespDto> implementJudgmentStartingPointCom(@RequestBody @Validated ImplementJudgmentStartingPointComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.implementJudgmentStartingPointCom(reqDTO));
    }
/**
   * D3判断当前时间点是否节假日(公共)
   */
    @PostMapping("judgeCurrentTimePointIshHolidayCom")
    public OkrResult<JudgeCurrentTimePointIshHolidayComRespDto> judgeCurrentTimePointIshHolidayCom(@RequestBody @Validated JudgeCurrentTimePointIshHolidayComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.judgeCurrentTimePointIshHolidayCom(reqDTO));
    }
/**
   * D3判断区间内节假日天数(公共)
   */
    @PostMapping("judgeIntervalHolidayDaysCom")
    public OkrResult<JudgeIntervalHolidayDaysComRespDto> judgeIntervalHolidayDaysCom(@RequestBody @Validated JudgeIntervalHolidayDaysComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.judgeIntervalHolidayDaysCom(reqDTO));
    }
/**
   * D3执行判断时间点是否节假日(公共)
   */
    @PostMapping("implementJudgeCurrentTimePointIshHolidayCom")
    public OkrResult<ImplementJudgeCurrentTimePointIshHolidayComRespDto> implementJudgeCurrentTimePointIshHolidayCom(@RequestBody @Validated ImplementJudgeCurrentTimePointIshHolidayComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.implementJudgeCurrentTimePointIshHolidayCom(reqDTO));
    }
/**
   * D3判断区间内天数(公共)
   */
    @PostMapping("judgeIntervalDaysCom")
    public OkrResult<JudgeIntervalDaysComRespDto> judgeIntervalDaysCom(@RequestBody @Validated JudgeIntervalDaysComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.judgeIntervalDaysCom(reqDTO));
    }
/**
   * D3-4新增周期(公共)
   */
    @PostMapping("addCycleCom")
    public OkrResult<AddCycleComRespDto> addCycleCom(@RequestBody @Validated AddCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addCycleCom(reqDTO));
    }
/**
   * D3自动生成标准工作与节假日(公共)
   */
    @PostMapping("autoAenerateStandardWorkingDaysHolidaysCom")
    public OkrResult<AutoAenerateStandardWorkingDaysHolidaysComRespDto> autoAenerateStandardWorkingDaysHolidaysCom(@RequestBody @Validated AutoAenerateStandardWorkingDaysHolidaysComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.autoAenerateStandardWorkingDaysHolidaysCom(reqDTO));
    }
/**
   * D3新增平台周期(公共)
   */
    @PostMapping("addPlatformCycleCom")
    public OkrResult<AddPlatformCycleComRespDto> addPlatformCycleCom(@RequestBody @Validated AddPlatformCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addPlatformCycleCom(reqDTO));
    }
/**
   * D3自动生成自定义工作与节假日(公共)
   */
    @PostMapping("autoAenerateCustomWorkingDaysHolidaysCom")
    public OkrResult<AutoAenerateCustomWorkingDaysHolidaysComRespDto> autoAenerateCustomWorkingDaysHolidaysCom(@RequestBody @Validated AutoAenerateCustomWorkingDaysHolidaysComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.autoAenerateCustomWorkingDaysHolidaysCom(reqDTO));
    }
/**
   * D3-4修改周期(公共)
   */
    @PostMapping("updateCycleCom")
    public OkrResult<UpdateCycleComRespDto> updateCycleCom(@RequestBody @Validated UpdateCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.updateCycleCom(reqDTO));
    }
/**
   * D3新增租户周期(公共)
   */
    @PostMapping("addSpaceCycleCom")
    public OkrResult<AddSpaceCycleComRespDto> addSpaceCycleCom(@RequestBody @Validated AddSpaceCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addSpaceCycleCom(reqDTO));
    }
/**
   * D3修改平台周期(公共)
   */
    @PostMapping("updatePlatformCycleCom")
    public OkrResult<UpdatePlatformCycleComRespDto> updatePlatformCycleCom(@RequestBody @Validated UpdatePlatformCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.updatePlatformCycleCom(reqDTO));
    }
/**
   * D3修改租户周期(公共)
   */
    @PostMapping("updateTenantCycleCom")
    public OkrResult<UpdateTenantCycleComRespDto> updateTenantCycleCom(@RequestBody @Validated UpdateTenantCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.updateTenantCycleCom(reqDTO));
    }
/**
   * D3删除平台周期
   */
    @PostMapping("deletePlatformCycle")
    public OkrResult<DeletePlatformCycleRespDto> deletePlatformCycle(@RequestBody @Validated DeletePlatformCycleReqDto reqDTO){
    return OkrResult.success(cycleTypeService.deletePlatformCycle(reqDTO));
    }
/**
   * D3-执行目标内容父中周期类型分析(公共)
   */
    @PostMapping("implementContentFatherAndMidCycleTypeAnalysisCom")
    public OkrResult<ImplementContentFatherAndMidCycleTypeAnalysisComRespDto> implementContentFatherAndMidCycleTypeAnalysisCom(@RequestBody @Validated ImplementContentFatherAndMidCycleTypeAnalysisComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.implementContentFatherAndMidCycleTypeAnalysisCom(reqDTO));
    }
/**
   * D3-3执行当前向右周期类型分析(公共)
   */
    @PostMapping("implementFatherCycleTypeAnalysisCom")
    public OkrResult<ImplementFatherCycleTypeAnalysisComRespDto> implementFatherCycleTypeAnalysisCom(@RequestBody @Validated ImplementFatherCycleTypeAnalysisComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.implementFatherCycleTypeAnalysisCom(reqDTO));
    }
/**
   * D3-判断父子中周期(公共)
   */
    @PostMapping("judgeParentSonMidCycleCom")
    public OkrResult<JudgeParentSonMidCycleComRespDto> judgeParentSonMidCycleCom(@RequestBody @Validated JudgeParentSonMidCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.judgeParentSonMidCycleCom(reqDTO));
    }
/**
   * D3-执行目标内容周期类型分析(公共)
   */
    @PostMapping("implementContentCycleTypeAnalysisCom")
    public OkrResult<ImplementContentCycleTypeAnalysisComRespDto> implementContentCycleTypeAnalysisCom(@RequestBody @Validated ImplementContentCycleTypeAnalysisComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.implementContentCycleTypeAnalysisCom(reqDTO));
    }
/**
   * D3-执行向右周期类型分析(公共)
   */
    @PostMapping("implementFatherProcessCycleTypeAnalysisCom")
    public OkrResult<ImplementFatherProcessCycleTypeAnalysisComRespDto> implementFatherProcessCycleTypeAnalysisCom(@RequestBody @Validated ImplementFatherProcessCycleTypeAnalysisComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.implementFatherProcessCycleTypeAnalysisCom(reqDTO));
    }
/**
   * D3新增不规则周期(公共)
   */
    @PostMapping("addIrregularCycleCom")
    public OkrResult<AddIrregularCycleComRespDto> addIrregularCycleCom(@RequestBody @Validated AddIrregularCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.addIrregularCycleCom(reqDTO));
    }
/**
   * D3获取周期类型(公共)
   */
    @PostMapping("obtainCycleTypeCom")
    public OkrResult<ObtainCycleTypeComRespDto> obtainCycleTypeCom(@RequestBody @Validated ObtainCycleTypeComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.obtainCycleTypeCom(reqDTO));
    }
/**
   * D3批量查询周期(公共)
   */
    @PostMapping("batchQueryCycleCom")
    public OkrResult<BatchQueryCycleComRespDto> batchQueryCycleCom(@RequestBody @Validated BatchQueryCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.batchQueryCycleCom(reqDTO));
    }
/**
   * D3分析租户周期(公共)
   */
    @PostMapping("analysisTenementCycleCom")
    public OkrResult<AnalysisTenementCycleComRespDto> analysisTenementCycleCom(@RequestBody @Validated AnalysisTenementCycleComReqDto reqDTO){
    return OkrResult.success(cycleTypeService.analysisTenementCycleCom(reqDTO));
    }
}
